Python Circuit Breaker: Erstellung fehlertoleranter Anwendungen

In der Welt der verteilten Systeme und Microservices ist der Umgang mit Fehlern unvermeidlich. Dienste können aufgrund von Netzwerkproblemen, überlasteten Servern oder unerwarteten Fehlern nicht verfügbar werden. Wenn ein fehlerhafter Dienst nicht richtig behandelt wird, kann dies zu kaskadierenden Fehlern führen, die ganze Systeme zum Absturz bringen. Das Circuit Breaker-Muster ist eine leistungsstarke Technik, um diese kaskadierenden Fehler zu verhindern und robustere Anwendungen zu erstellen. Dieser Artikel bietet eine umfassende Anleitung zur Implementierung des Circuit Breaker-Musters in Python.

Was ist das Circuit Breaker-Muster?

Das Circuit Breaker-Muster, inspiriert von elektrischen Schutzschaltern, fungiert als Proxy für Operationen, die fehlschlagen könnten. Es überwacht die Erfolgs- und Fehlerraten dieser Operationen und „schaltet“ den Stromkreis, wenn ein bestimmter Schwellenwert an Fehlern erreicht ist, wodurch weitere Aufrufe des fehlerhaften Dienstes verhindert werden. Dies ermöglicht dem fehlerhaften Dienst Zeit zur Wiederherstellung, ohne von Anfragen überlastet zu werden, und verhindert, dass der aufrufende Dienst Ressourcen verschwendet, indem er versucht, sich mit einem Dienst zu verbinden, von dem bekannt ist, dass er ausgefallen ist.

Der Circuit Breaker hat drei Hauptzustände:

• Geschlossen: Der Schutzschalter befindet sich in seinem Normalzustand und lässt Aufrufe zum geschützten Dienst durch. Er überwacht den Erfolg und das Scheitern dieser Aufrufe.
• Geöffnet: Der Schutzschalter ist ausgelöst und alle Aufrufe des geschützten Dienstes werden blockiert. Nach einer bestimmten Zeitüberschreitungsdauer wechselt der Schutzschalter in den Halboffen-Zustand.
• Halb-Offen: Der Schutzschalter erlaubt eine begrenzte Anzahl von Testaufrufen an den geschützten Dienst. Wenn diese Aufrufe erfolgreich sind, kehrt der Schutzschalter in den Geschlossen-Zustand zurück. Wenn sie fehlschlagen, kehrt er in den Geöffnet-Zustand zurück.

Hier ist eine einfache Analogie: Stellen Sie sich vor, Sie versuchen, Geld von einem Geldautomaten abzuheben. Wenn der Geldautomat wiederholt kein Bargeld ausgibt (möglicherweise aufgrund eines Systemfehlers bei der Bank), würde ein Circuit Breaker eingreifen. Anstatt weiterhin Abhebungsversuche zu unternehmen, die wahrscheinlich fehlschlagen, würde der Circuit Breaker vorübergehend weitere Versuche blockieren (Geöffnet-Zustand). Nach einer Weile könnte er einen einzelnen Abhebungsversuch zulassen (Halboffen-Zustand). Wenn dieser Versuch erfolgreich ist, würde der Circuit Breaker den normalen Betrieb wieder aufnehmen (Geschlossen-Zustand). Wenn er fehlschlägt, würde der Circuit Breaker für einen längeren Zeitraum im Geöffnet-Zustand verbleiben.

Warum einen Circuit Breaker verwenden?

Die Implementierung eines Circuit Breakers bietet mehrere Vorteile:

• Verhindert kaskadierende Fehler: Durch das Blockieren von Aufrufen an einen fehlerhaften Dienst verhindert der Circuit Breaker, dass sich der Fehler auf andere Teile des Systems ausbreitet.
• Verbessert die Systemresilienz: Der Circuit Breaker ermöglicht es fehlerhaften Diensten, sich zu erholen, ohne von Anfragen überlastet zu werden, was zu einem stabileren und widerstandsfähigeren System führt.
• Reduziert den Ressourcenverbrauch: Durch das Vermeiden unnötiger Aufrufe an einen fehlerhaften Dienst reduziert der Circuit Breaker den Ressourcenverbrauch sowohl auf dem aufrufenden als auch auf dem aufgerufenen Dienst.
• Bietet Fallback-Mechanismen: Wenn der Stromkreis geöffnet ist, kann der aufrufende Dienst einen Fallback-Mechanismus ausführen, z. B. einen zwischengespeicherten Wert zurückgeben oder eine Fehlermeldung anzeigen, was zu einer besseren Benutzererfahrung führt.

Implementierung eines Circuit Breakers in Python

Es gibt verschiedene Möglichkeiten, das Circuit Breaker-Muster in Python zu implementieren. Sie können Ihre eigene Implementierung von Grund auf erstellen oder eine Bibliothek von Drittanbietern verwenden. Hier werden wir beide Ansätze untersuchen.

1. Erstellen eines benutzerdefinierten Circuit Breakers

Beginnen wir mit einer einfachen, benutzerdefinierten Implementierung, um die Kernkonzepte zu verstehen. In diesem Beispiel werden das `threading`-Modul für die Thread-Sicherheit und das `time`-Modul für die Behandlung von Timeouts verwendet.

            
import time
import threading

class CircuitBreaker:
    def __init__(self, failure_threshold, recovery_timeout):
        self.failure_threshold = failure_threshold
        self.recovery_timeout = recovery_timeout
        self.state = "CLOSED"
        self.failure_count = 0
        self.last_failure_time = None
        self.lock = threading.Lock()

    def call(self, func, *args, **kwargs):
        with self.lock:
            if self.state == "OPEN":
                if time.time() - self.last_failure_time > self.recovery_timeout:
                    self.state = "HALF_OPEN"
                else:
                    raise CircuitBreakerError("Circuit breaker is open")

        try:
            result = func(*args, **kwargs)
            self.reset()
            return result
        except Exception as e:
            self.record_failure()
            raise e

    def record_failure(self):
        with self.lock:
            self.failure_count += 1
            self.last_failure_time = time.time()

            if self.failure_count >= self.failure_threshold:
                self.state = "OPEN"
                print("Circuit breaker opened")

    def reset(self):
        with self.lock:
            self.failure_count = 0
            self.state = "CLOSED"
            print("Circuit breaker closed")

class CircuitBreakerError(Exception):
    pass

# Example Usage
def unreliable_service():
    # Simulate a service that sometimes fails
    import random
    if random.random() < 0.5:
        raise Exception("Service failed")
    else:
        return "Service successful"

circuit_breaker = CircuitBreaker(failure_threshold=3, recovery_timeout=10)

for i in range(10):
    try:
        result = circuit_breaker.call(unreliable_service)
        print(f"Call {i+1}: {result}")
    except CircuitBreakerError as e:
        print(f"Call {i+1}: {e}")
    except Exception as e:
        print(f"Call {i+1}: Service failed: {e}")
    time.sleep(1) 

            

              
                Copy
              
            
          

Erläuterung:

• `CircuitBreaker`-Klasse:
  • `__init__(self, failure_threshold, recovery_timeout)`: Initialisiert den Schutzschalter mit einem Fehlerschwellenwert (die Anzahl der Fehler, bevor der Stromkreis ausgelöst wird), einem Wiederherstellungs-Timeout (die Wartezeit, bevor ein Halboffen-Zustand versucht wird) und setzt den Anfangszustand auf `GESCHLOSSEN`.
  • `call(self, func, *args, **kwargs)`: Dies ist die Hauptmethode, die die Funktion umschließt, die Sie schützen möchten. Sie prüft den aktuellen Zustand des Schutzschalters. Wenn er `GEÖFFNET` ist, wird geprüft, ob das Wiederherstellungs-Timeout abgelaufen ist. Wenn ja, wechselt er zu `HALB_GEÖFFNET`. Andernfalls wird ein `CircuitBreakerError` ausgelöst. Wenn der Zustand nicht `GEÖFFNET` ist, führt er die Funktion aus und behandelt potenzielle Ausnahmen.
  • `record_failure(self)`: Erhöht die Fehleranzahl und zeichnet die Zeit des Fehlers auf. Wenn die Fehleranzahl den Schwellenwert überschreitet, wechselt er den Stromkreis in den Zustand `GEÖFFNET`.
  • `reset(self)`: Setzt die Fehleranzahl zurück und wechselt den Stromkreis in den Zustand `GESCHLOSSEN`.
• `CircuitBreakerError`-Klasse: Eine benutzerdefinierte Ausnahme, die ausgelöst wird, wenn der Schutzschalter geöffnet ist.
• `unreliable_service()`-Funktion: Simuliert einen Dienst, der zufällig ausfällt.
• Beispielverwendung: Zeigt, wie die `CircuitBreaker`-Klasse verwendet wird, um die Funktion `unreliable_service()` zu schützen.

Wichtige Überlegungen für die benutzerdefinierte Implementierung:

• Threadsicherheit: Das `threading.Lock()` ist entscheidend, um die Thread-Sicherheit zu gewährleisten, insbesondere in nebenläufigen Umgebungen.
• Fehlerbehandlung: Der `try...except`-Block fängt Ausnahmen vom geschützten Dienst ab und ruft `record_failure()` auf.
• Zustandsübergänge: Die Logik für den Übergang zwischen den Zuständen `GESCHLOSSEN`, `GEÖFFNET` und `HALB_GEÖFFNET` wird in den Methoden `call()` und `record_failure()` implementiert.

2. Verwenden einer Bibliothek von Drittanbietern: `pybreaker`

Obwohl das Erstellen eines eigenen Circuit Breakers eine gute Lernerfahrung sein kann, ist die Verwendung einer gut getesteten Bibliothek von Drittanbietern oft eine bessere Option für Produktionsumgebungen. Eine beliebte Python-Bibliothek zur Implementierung des Circuit Breaker-Musters ist `pybreaker`.

Installation:

            
pip install pybreaker

            

              
                Copy
              
            
          

Beispielverwendung:

            
import pybreaker
import time

# Definieren Sie eine benutzerdefinierte Ausnahme für unseren Dienst
class ServiceError(Exception):
    pass

# Simulieren Sie einen unzuverlässigen Dienst
def unreliable_service():
    import random
    if random.random() < 0.5:
        raise ServiceError("Service failed")
    else:
        return "Service successful"

# Erstellen Sie eine CircuitBreaker-Instanz
circuit_breaker = pybreaker.CircuitBreaker(
    fail_max=3,  # Anzahl der Fehler vor dem Öffnen des Stromkreises
    reset_timeout=10,  # Zeit in Sekunden, bevor versucht wird, den Stromkreis zu schließen
    name="MyService"
)

# Umschließen Sie den unzuverlässigen Dienst mit dem CircuitBreaker
@circuit_breaker
def call_unreliable_service():
    return unreliable_service()

# Rufen Sie den Dienst auf
for i in range(10):
    try:
        result = call_unreliable_service()
        print(f"Call {i+1}: {result}")
    except pybreaker.CircuitBreakerError as e:
        print(f"Call {i+1}: Circuit breaker is open: {e}")
    except ServiceError as e:
        print(f"Call {i+1}: Service failed: {e}")
    time.sleep(1)

            

              
                Copy
              
            
          

Erläuterung:

• Installation: Der Befehl `pip install pybreaker` installiert die Bibliothek.
• `pybreaker.CircuitBreaker`-Klasse:
  • `fail_max`: Gibt die Anzahl der aufeinanderfolgenden Fehler an, bevor der Schutzschalter öffnet.
  • `reset_timeout`: Gibt die Zeit (in Sekunden) an, die der Schutzschalter geöffnet bleibt, bevor er in den Halboffen-Zustand übergeht.
  • `name`: Ein beschreibender Name für den Schutzschalter.
• Dekorateur: Der Dekorateur `@circuit_breaker` umschließt die Funktion `unreliable_service()` und kümmert sich automatisch um die Logik des Schutzschalters.
• Ausnahmebehandlung: Der `try...except`-Block fängt `pybreaker.CircuitBreakerError` ab, wenn der Stromkreis geöffnet ist, und `ServiceError` (unsere benutzerdefinierte Ausnahme), wenn der Dienst fehlschlägt.

Vorteile der Verwendung von `pybreaker`:

• Vereinfachte Implementierung: `pybreaker` bietet eine saubere und einfach zu verwendende API, wodurch der Boilerplate-Code reduziert wird.
• Threadsicherheit: `pybreaker` ist threadsicher, was ihn für nebenläufige Anwendungen geeignet macht.
• Anpassbar: Sie können verschiedene Parameter konfigurieren, z. B. den Fehlerschwellenwert, das Reset-Timeout und Ereignis-Listener.
• Ereignis-Listener: `pybreaker` unterstützt Ereignis-Listener, mit denen Sie den Zustand des Schutzschalters überwachen und entsprechende Aktionen ausführen können (z. B. Protokollierung, Senden von Warnungen).

3. Erweiterte Circuit Breaker-Konzepte

Neben der grundlegenden Implementierung gibt es mehrere erweiterte Konzepte, die bei der Verwendung von Circuit Breakern berücksichtigt werden sollten:

• Metriken und Überwachung: Das Sammeln von Metriken zur Leistung Ihrer Circuit Breaker ist unerlässlich, um ihr Verhalten zu verstehen und potenzielle Probleme zu identifizieren. Bibliotheken wie Prometheus und Grafana können verwendet werden, um diese Metriken zu visualisieren. Verfolgen Sie Metriken wie:
• Circuit Breaker-Zustand (Geöffnet, Geschlossen, Halboffen)
• Anzahl der erfolgreichen Aufrufe
• Anzahl der fehlgeschlagenen Aufrufe
• Latenz der Aufrufe
• Fallback-Mechanismen: Wenn der Stromkreis geöffnet ist, benötigen Sie eine Strategie für die Verarbeitung von Anfragen. Häufige Fallback-Mechanismen sind:
• Zurückgeben eines zwischengespeicherten Werts.
• Anzeigen einer Fehlermeldung für den Benutzer.
• Aufrufen eines alternativen Dienstes.
• Zurückgeben eines Standardwerts.
• Asynchrone Circuit Breaker: In asynchronen Anwendungen (mit `asyncio`) müssen Sie eine asynchrone Circuit Breaker-Implementierung verwenden. Einige Bibliotheken bieten asynchrone Unterstützung.
• Bulkheads: Das Bulkhead-Muster isoliert Teile einer Anwendung, um zu verhindern, dass Fehler in einem Teil auf andere übergreifen. Circuit Breaker können in Verbindung mit Bulkheads verwendet werden, um eine noch höhere Fehlertoleranz zu bieten.
• Zeitbasierte Circuit Breaker: Anstatt die Anzahl der Fehler zu verfolgen, öffnet ein zeitbasierter Circuit Breaker den Stromkreis, wenn die durchschnittliche Antwortzeit des geschützten Dienstes innerhalb eines bestimmten Zeitfensters einen bestimmten Schwellenwert überschreitet.

Praktische Beispiele und Anwendungsfälle

Hier sind ein paar praktische Beispiele, wie Sie Circuit Breaker in verschiedenen Szenarien verwenden können:

• Microservices-Architektur: In einer Microservices-Architektur hängen Dienste oft voneinander ab. Ein Circuit Breaker kann einen Dienst davor schützen, von Fehlern in einem nachgelagerten Dienst überlastet zu werden. Beispielsweise kann eine E-Commerce-Anwendung separate Microservices für Produktkatalog, Auftragsabwicklung und Zahlungsabwicklung haben. Wenn der Zahlungsabwicklungsdienst nicht verfügbar ist, kann ein Circuit Breaker im Auftragsabwicklungsdienst verhindern, dass neue Bestellungen erstellt werden, wodurch ein kaskadierender Fehler verhindert wird.
• Datenbankverbindungen: Wenn Ihre Anwendung häufig eine Verbindung zu einer Datenbank herstellt, kann ein Circuit Breaker Verbindungsschwemmen verhindern, wenn die Datenbank nicht verfügbar ist. Stellen Sie sich eine Anwendung vor, die eine Verbindung zu einer geografisch verteilten Datenbank herstellt. Wenn ein Netzwerkausfall eine der Datenbankregionen beeinträchtigt, kann ein Circuit Breaker verhindern, dass die Anwendung wiederholt versucht, sich mit der nicht verfügbaren Region zu verbinden, wodurch die Leistung und Stabilität verbessert werden.
• Externe APIs: Beim Aufrufen externer APIs kann ein Circuit Breaker Ihre Anwendung vor vorübergehenden Fehlern und Ausfällen schützen. Viele Organisationen verlassen sich auf APIs von Drittanbietern für verschiedene Funktionen. Durch das Umschließen von API-Aufrufen mit einem Circuit Breaker können Organisationen robustere Integrationen erstellen und die Auswirkungen von Ausfällen externer APIs reduzieren.
• Wiederholungslogik: Circuit Breaker können in Verbindung mit der Wiederholungslogik arbeiten. Es ist jedoch wichtig, aggressive Wiederholungen zu vermeiden, die das Problem verschlimmern können. Der Circuit Breaker sollte Wiederholungen verhindern, wenn der Dienst bekanntermaßen nicht verfügbar ist.

Globale Überlegungen

Bei der Implementierung von Circuit Breakern in einem globalen Kontext ist Folgendes zu berücksichtigen:

• Netzwerklatenz: Die Netzwerklatenz kann je nach geografischer Lage der aufrufenden und aufgerufenen Dienste erheblich variieren. Passen Sie das Wiederherstellungs-Timeout entsprechend an. Beispielsweise kann es zwischen Diensten in Nordamerika und Europa zu einer höheren Latenz kommen als zu Aufrufen innerhalb derselben Region.
• Zeitzonen: Stellen Sie sicher, dass alle Zeitstempel konsistent über verschiedene Zeitzonen hinweg verarbeitet werden. Verwenden Sie UTC zum Speichern von Zeitstempeln.
• Regionale Ausfälle: Berücksichtigen Sie die Möglichkeit regionaler Ausfälle und implementieren Sie Circuit Breaker, um Fehler auf bestimmte Regionen zu isolieren.
• Kulturelle Aspekte: Berücksichtigen Sie bei der Gestaltung von Fallback-Mechanismen den kulturellen Kontext Ihrer Benutzer. Beispielsweise sollten Fehlermeldungen lokalisiert und kulturell angemessen sein.

Best Practices

Hier sind einige Best Practices für die effektive Verwendung von Circuit Breakern:

• Beginnen Sie mit konservativen Einstellungen: Beginnen Sie mit einem relativ niedrigen Fehlerschwellenwert und einem längeren Wiederherstellungs-Timeout. Überwachen Sie das Verhalten des Schutzschalters und passen Sie die Einstellungen nach Bedarf an.
• Verwenden Sie geeignete Fallback-Mechanismen: Wählen Sie Fallback-Mechanismen, die eine gute Benutzererfahrung bieten und die Auswirkungen von Fehlern minimieren.
• Überwachen Sie den Zustand des Schutzschalters: Verfolgen Sie den Zustand Ihrer Circuit Breaker und richten Sie Warnungen ein, um Sie zu benachrichtigen, wenn ein Stromkreis geöffnet ist.
• Testen Sie das Verhalten des Circuit Breakers: Simulieren Sie Fehler in Ihrer Testumgebung, um sicherzustellen, dass Ihre Circuit Breaker korrekt arbeiten.
• Vermeiden Sie die übermäßige Abhängigkeit von Circuit Breakern: Circuit Breaker sind ein Werkzeug zur Minderung von Fehlern, aber sie sind kein Ersatz für die Behebung der zugrunde liegenden Ursachen dieser Fehler. Untersuchen und beheben Sie die Ursachen der Dienstinstabilität.
• Berücksichtigen Sie Distributed Tracing: Integrieren Sie Distributed-Tracing-Tools (wie Jaeger oder Zipkin), um Anfragen über mehrere Dienste hinweg zu verfolgen. Dies kann Ihnen helfen, die Ursache von Fehlern zu ermitteln und die Auswirkungen von Circuit Breakern auf das Gesamtsystem zu verstehen.

Fazit

Das Circuit Breaker-Muster ist ein wertvolles Werkzeug zum Erstellen fehlertoleranter und robuster Anwendungen. Indem sie kaskadierende Fehler verhindern und fehlgeschlagenen Diensten Zeit zur Wiederherstellung geben, können Circuit Breaker die Systemstabilität und -verfügbarkeit erheblich verbessern. Unabhängig davon, ob Sie Ihre eigene Implementierung erstellen oder eine Bibliothek eines Drittanbieters wie `pybreaker` verwenden, ist das Verständnis der Kernkonzepte und Best Practices des Circuit Breaker-Musters unerlässlich, um robuste und zuverlässige Software in den heutigen komplexen verteilten Umgebungen zu entwickeln.

Durch die Umsetzung der in diesem Leitfaden beschriebenen Prinzipien können Sie Python-Anwendungen erstellen, die widerstandsfähiger gegen Fehler sind und eine bessere Benutzererfahrung und ein stabileres System gewährleisten, unabhängig von Ihrer globalen Reichweite.